
#include "BlocObjet.h"

#include <stdio.h>
#include <assert.h>

/* tableau des associations bloc <-> caractère :

'*' == mur
' ' == dalle
'.' == herbe
'-' == touffe_herbe
'_' == fleur1
'#' == bord
'%' == porte

*/

bool bloAccessible (const BlocObjet* p_BlocO)
{
	switch (p_BlocO->bloc)
	{
        case dalle :
		case herbe :
		case touffe_herbe :
		case fleur1 :
		case bord :
			return true;
		default :
			return false;
	}
}

bool bloChangeurDeZone (Bloc bloc)
{
	switch (bloc)
	{
		case bord :
		case porte :
			return true;
		default :
			return false;
	}
}



char bloCaractereDepuisBloc (Bloc bloc)
{
    char resultat;

    switch (bloc)
    {
        case mur :
            resultat = '*';
            break;
        case dalle :
            resultat = ' ';
            break;
        case herbe :
            resultat = '.';
            break;
        case touffe_herbe :
            resultat = '-';
            break;
        case fleur1 :
            resultat = '_';
            break;
		case bord :
			resultat = '#';
			break;
		case porte :
			resultat = '%';
			break;
    }

    return resultat;
}

/* Rappel : à noter qu'elle initialise aussi l'objet à aucun */
void bloSetDepuisCaractere(BlocObjet* p_BlocO, char caractere)
{
    p_BlocO->objet = aucun;

	switch(caractere)
	{
		case '*' :
			p_BlocO->bloc = mur;
			break;
		case ' ' :
			p_BlocO->bloc = dalle;
			break;
        case '.' :
			p_BlocO->bloc = herbe;
			break;
        case '-' :
            p_BlocO->bloc = touffe_herbe;
			break;
        case '_' :
			p_BlocO->bloc = fleur1;
			break;
	    case '#' :
			p_BlocO->bloc = bord;
			break;
		case '%' :
			p_BlocO->bloc = porte;
			break;
		default :
			fprintf(stderr, "Erreur caractère invalide, pas de bloc correspondant : %c (code ASCII : %d)\n", caractere, caractere);
	}
}


void bloSetObjet(BlocObjet* p_BlocO, Objet obj)
{
	p_BlocO->objet = obj;
}


Objet bloGetObjet (const BlocObjet* p_BlocObjet)
{
    return p_BlocObjet->objet;
}

Bloc bloGetBloc (const BlocObjet* p_BlocObjet)
{
    return p_BlocObjet->bloc;
}


bool bloTestRegression()
{
	char a = '*';
	char b = ' ';
	char c = '#';

	char e,f;

	BlocObjet a_bloc;
	BlocObjet b_bloc;
	BlocObjet c_bloc;

	int i;
	printf("taille d'une variable de type enum : %d , int :%d \n", sizeof(a_bloc),sizeof(i));
	printf("valeur de mur : %d, herbe : %d, bord : %d \n", mur, herbe, bord);

	bloSetDepuisCaractere(&a_bloc, a);
	printf("caractere %c est un ",a);
	if (a_bloc.bloc == mur) {printf("mur \n");} else {printf("inconnu \n");}

	bloSetDepuisCaractere(&b_bloc, b);
	printf("caractere %c est de ",b);
	if (b_bloc.bloc == herbe) {printf("l'herbe \n");} else {printf("inconnu \n");}


	bloSetDepuisCaractere(&c_bloc, c);
	switch(c_bloc.bloc)
	{
		case mur :
			printf("le caractere %c est un mur \n",c);
			break;
		case herbe :
			printf("le caractere %c est de l'herbe \n",c);
			break;
        case bord :
			printf("%c est un changeur de zone (bord) \n",c);
			break;
		default:
			printf("autre \n");
	}



    e = bloCaractereDepuisBloc(a_bloc.bloc);
    f = bloCaractereDepuisBloc(b_bloc.bloc);

    printf("e : '%c' \n", e);
    printf("f : '%c' \n", f);


	return true;
}

